/**
 * Redmine 风格的时间格式转换工具
 * 前端 JavaScript 版本，用于实时输入验证和格式化
 */

class TimeConverter {
    /**
     * 将时间字符串转换为小时数
     * @param {string} timeStr - 时间字符串
     * @returns {number|null} 转换后的小时数，失败返回 null
     */
    static toHours(timeStr) {
        if (!timeStr || typeof timeStr !== 'string') {
            return null;
        }
        
        const s = timeStr.trim();
        
        // 格式1：数字[.数字]h?  例如：2.5, 2.5h, 2,5h
        const numberPattern = /^(\\d+[.,]\\d+?)h?$/;
        const numberMatch = s.match(numberPattern);
        if (numberMatch) {
            const numberStr = numberMatch[1].replace(',', '.');
            const result = parseFloat(numberStr);
            return isNaN(result) ? null : result;
        }
        
        // 格式2：小时:分钟  例如：2:30 → 2.5
        const timePattern = /^(\\d+):(\\d+)$/;
        const timeMatch = s.match(timePattern);
        if (timeMatch) {
            const hours = parseInt(timeMatch[1], 10);
            const minutes = parseInt(timeMatch[2], 10);
            return hours + minutes / 60;
        }
        
        // 格式3：小时 + 分钟组合  例如：2h30m, 2h, 30m
        const combinedPattern = /^((\\d+)\\s*(h|hours?))?\\s*((\\d+)\\s*(m|min))?$/i;
        const combinedMatch = s.match(combinedPattern);
        if (combinedMatch) {
            const hourPart = combinedMatch[1];
            const minutePart = combinedMatch[4];
            
            let totalHours = 0;
            
            if (hourPart) {
                const hours = parseInt(combinedMatch[2], 10);
                if (!isNaN(hours)) {
                    totalHours += hours;
                }
            }
            
            if (minutePart) {
                const minutes = parseInt(combinedMatch[5], 10);
                if (!isNaN(minutes)) {
                    totalHours += minutes / 60;
                }
            }
            
            return totalHours > 0 ? totalHours : null;
        }
        
        return null;
    }
    
    /**
     * 计算剩余预期时间
     * @param {number} estimatedHours - 预期时间
     * @param {number} doneRatio - 完成百分比 (0-100)
     * @returns {number} 剩余预期时间
     */
    static calculateRemainingHours(estimatedHours, doneRatio) {
        if (!estimatedHours || estimatedHours <= 0) {
            return 0;
        }
        
        const ratio = (doneRatio >= 0 && doneRatio <= 100) ? doneRatio : 0;
        return estimatedHours * (100 - ratio) / 100;
    }
    
    /**
     * 验证时间输入是否有效
     * @param {string} input - 用户输入
     * @returns {boolean} 是否有效
     */
    static isValidTimeInput(input) {
        return this.toHours(input) !== null;
    }
    
    /**
     * 格式化时间显示
     * @param {number} hours - 小时数
     * @returns {string} 格式化后的字符串
     */
    static formatHours(hours) {
        if (hours === null || isNaN(hours)) {
            return '';
        }
        
        // 如果是整数，直接显示
        if (Number.isInteger(hours)) {
            return hours.toString();
        }
        
        // 如果有半小时，显示为 .5
        if (hours % 0.5 === 0) {
            return hours.toString();
        }
        
        // 否则显示两位小数
        return hours.toFixed(2);
    }
    
    /**
     * 实时输入验证和转换
     * @param {HTMLInputElement} inputElement - 输入框元素
     * @param {HTMLElement} displayElement - 显示转换结果的元素
     */
    static setupTimeInputConverter(inputElement, displayElement) {
        inputElement.addEventListener('input', (e) => {
            const value = e.target.value;
            const hours = this.toHours(value);
            
            if (hours !== null) {
                inputElement.setCustomValidity('');
                if (displayElement) {
                    displayElement.textContent = `= ${this.formatHours(hours)} 小时`;
                    displayElement.style.color = '#2ecc71';
                }
            } else {
                inputElement.setCustomValidity('请输入有效的时间格式');
                if (displayElement) {
                    displayElement.textContent = '格式：2.5h, 2:30, 2h30m 等';
                    displayElement.style.color = '#e74c3c';
                }
            }
        });
    }
}

// 使用示例和测试
if (typeof module !== 'undefined' && module.exports) {
    // Node.js 环境
    module.exports = TimeConverter;
} else {
    // 浏览器环境，添加到全局对象
    window.TimeConverter = TimeConverter;
}

// 测试用例
function runTests() {
    const testCases = [
        '2.5', '2,5', '2.5h', '2,5h',
        '2:30', '1:45',
        '2h30m', '2h', '30m', '45m',
        '1h30m', '3hours', '2min',
        'invalid', '', null
    ];
    
    console.log('JavaScript 时间转换测试:');
    testCases.forEach(testCase => {
        const result = TimeConverter.toHours(testCase);
        console.log(`'${testCase}' → ${result !== null ? result.toFixed(2) : 'null'} 小时`);
    });
    
    console.log('\\n剩余时间计算测试:');
    console.log(`预期: 100小时, 完成: 30% → 剩余: ${TimeConverter.calculateRemainingHours(100, 30).toFixed(1)}小时`);
    console.log(`预期: 40小时, 完成: 75% → 剩余: ${TimeConverter.calculateRemainingHours(40, 75).toFixed(1)}小时`);
}
